LGSSystem.builtins()['NaD1', 'Na330', 'NaD2', 'NaD2_Repump', 'NaD1_Toy']
LGSSystem (system:str, fixed_params:dict={})
LGSSystem creates numerical models for the chosen laser guide star atomic system.
| Type | Default | Details | |
|---|---|---|---|
| system | str | Name of the atomic system to be loaded from file | |
| fixed_params | dict | {} | Values for system parameters that will be held fixed |
LGSSystem.builtins ()
List the available LGS systems:
LGSSystem.diagram (name:str|pathlib.Path, kind='Toy')
Draw a level diagram for the system of the specified kind.
| Type | Default | Details | |
|---|---|---|---|
| name | str | pathlib.Path | Name of built-in LGS system definition, or directory of supplied system | |
| kind | str | Toy | “Toy” to show level diagram and pumped transitions, “ToScale” to show hyperfine structure to scale, “NotToScale” to show unscaled hf structure |
LGSSystem.info (name:str|pathlib.Path)
Display information about LGS system name.
| Type | Details | |
|---|---|---|
| name | str | pathlib.Path | Name of built-in LGS system definition, or directory of supplied system |
\(\text{3S}_{\frac{1}{2}}\), \(\text{3P}_{\frac{3}{2}}\)
Load a “toy” (no angular momentum) model LGS system and fix values for most of the parameters:
lgs = LGSSystem(
'NaD1_Toy',
fixed_params={'EllipticityDegrees1': 45.0,
'PolarizationAngleDegrees1': 0,
'DetuningHz1': 0,
'LaserWidthHz1': 10.0e6,
'BFieldG': 0.5,
'MagneticZenithDegrees': 45.0,
'MagneticAzimuthDegrees': 45.0,
'SDampingCollisionRatePerS': 4e3,
'BeamTransitRatePerS': 1e2,
'VccRatePerS': 3e4,
'TemperatureK': 2e2,
'RecoilParameter': 1,
}
)The only remaining parameter is the laser intensity. Here the value 1 indicates that the parameter is a scalar quantity:
Define a value for the intensity to use for the following examples:
LGSSystem.operator (vg:pylgs.velocitygroups.VelocityGroups)
The evolution operatior for the system, given the VelocityGroups vg.
| Type | Details | |
|---|---|---|
| vg | VelocityGroups | VelocityGroups specification |
| Returns | Operator |
Form the operator with the example VelocityGroups:
The operator operates on vectors from the \(2\times4\) (velocity \(\times\) density matrix) product vector space:
And returns a vector from the same space:
Substitute the free parameter values into the operator and write it explicitly as a block matrix, with \(2\times2\) blocks for the velocity space, each block being \(4\times4\) on the density matrix space:
array([[ 0.015 , 0 , -2.6e+01, -6.1e+01, -0.015 , 0 , 0 , 0 ],
[ 0 , 6.2e+01, -6.1e+03, 0 , 0 , 0 , 0 , 0 ],
[ 1.3e+01, 6.1e+03, 6.2e+01, -1.3e+01, 0 , 0 , 0 , 0 ],
[ 0 , 0 , 2.6e+01, 6.1e+01, 0 , 0 , 0 , -0.015 ],
[ -0.015 , 0 , 0 , -0.0016 , 0.015 , 0 , -2.6e+01, -6.1e+01],
[ 0 , 0 , 0 , 0 , 0 , 6.2e+01, 6.1e+03, 0 ],
[ 0 , 0 , 0 , 0 , 1.3e+01, -6.1e+03, 6.2e+01, -1.3e+01],
[ 0 , 0 , 0 , -0.015 , 0 , 0 , 2.6e+01, 6.1e+01]])
LGSSystem.rhs (vg:pylgs.velocitygroups.VelocityGroups)
The right-hand side vector for this system given the VelocityGroups vg.
| Type | Details | |
|---|---|---|
| vg | VelocityGroups | VelocityGroups specification |
| Returns | VectorArray |
Form the right-hand side VectorArray:
The vector is in the \(2\times4\) (velocity \(\times\) density matrix) product vector space:
Write as a flattened 1D vector:
LGSSystem.stationary_model (vg:Union[int,Iterable,pylgs.velocitygroups.V elocityGroups]=6)
Return a pyMOR StationaryModel for the steady state cw LGS system.
| Type | Default | Details | |
|---|---|---|---|
| vg | Union | 6 | Specification of velocity groups |
| Returns | StationaryModel | Model for the steady-state LGS system |
An integer can be supplied for vg to get that many evenly spaced velocity groups:
Solve the model and calculate the return flux by supplying values for all free parameters:
Solve the model and return the steady-state density matrix:
The solution can be visualized in several ways. Plot the flux for each velocity bin:
Plot the real and imaginary parts of the density-matrix elements for each velocity bin:
Plot just the level populations:
Plot the total atomic population:
Note that the above visualizations plot the contribution to the quantity from each velocity group. If the velocity groups are not all of the same width, this will cause the plots to appear distorted. In this case one can instead plot the velocity distribution of the quantities using flux_distribution, population_distribution, etc. To plot the velocity distribution of the density-matrix elements, use velocity_normalize(sol).
| Description | |
|---|---|
| population | Fraction of total atomic population in each velocity group |
| total_population | Total atomic population (should equal 1) |
| population_distribution | Atomic population per unit velocity interval |
| level_population | Population of each atomic level in each velocity group |
| total_level_population | Total atomic population in each level |
| level_population_distribution | Level population per unit velocity interval |
| flux | Return flux on each transition from each velocity group |
| total_flux | Total return flux |
| flux_distribution | Return flux per unit velocity interval |
| velocity_sum | Sum over velocity groups |
| velocity_normalize | Normalize by velocity-group width |
Check that the atomic population summed over all velocity groups is approximately 1:
LGSSystem.adaptive_stationary_model (mu, vg=6, max_weight=0.01)
Create a StationaryModel with narrower velocity bins in velocity regions with higher flux.
| Type | Default | Details | |
|---|---|---|---|
| mu | Parameter values to use during velocity-group refinement | ||
| vg | int | 6 | Initial velocity groups |
| max_weight | float | 0.01 | Maximum fraction of the return flux from any one velocity group |
| Returns | StationaryModel | Steady-state LGS model with more velocity groups in regions that produce more return flux |
Create a model with adaptively refined velocity groups using a particular value for the intensity parameter during refinement:
Solve and find total flux:
Solve for the density matrix. The solution has density-matrix values for 17 velocity groups:
Plot the velocity distribution of flux. Each point marks the center of a velocity group:
Velocity distribution of the density matrix:
Of the total population:
Of the level populations:
LGSSystem.instationary_model (vg:Union[int,Iterable,pylgs.velocitygroups .VelocityGroups]=6, T=1e-06, num_values=100, initial_rho=None, time_stepper=BDFTimeStepper())
Create an InstationaryModel for the LGS system dynamics.
| Type | Default | Details | |
|---|---|---|---|
| vg | Union | 6 | Specification of velocity groups |
| T | float | 1e-06 | Final time (seconds) |
| num_values | int | 100 | Number of time step values to return |
| initial_rho | NoneType | None | Initial density matrix. None means to use the thermal distribution |
| time_stepper | BDFTimeStepper | BDFTimeStepper() | Solver to use |
| Returns | InstationaryModel | Model for the LGS system dynamics |
An instationary model with 30 velocity groups:
The BDF solver is efficient but can be very sensitive to the absolute and relative tolerance values. Set appropriate values for this problem:
Solve for a constant value of intensity:
Visualize the total flux as a function of time:
Plot the density matrix elements as a function of atomic velocity and animate as a function of time:
Animate the population distribution as a function of time:
Animate the level population distributions:
Set a shorter evolution time for the model:
Solve the model with a modulated intensity parameter:
Visualize the total flux as a function of time:
Visualize the density matrix elements:
Visualize the flux distribution:
LGSSystem.stationary_floquet_model (mu, T, n_vector, nu:str='nu', n_operator=None, vg:Union[int,Iterabl e,pylgs.velocitygroups.VelocityGroups ]=6)
Return a StationaryFloquetModel for the Fourier coefficients of the periodic state of a modulated LGS system.
| Type | Default | Details | |
|---|---|---|---|
| mu | Parameter specification for parameters modulated at a frequency nu |
||
| T | List of time values to use for reconstruction | ||
| n_vector | Number of terms in the system Fourier series | ||
| nu | str | nu | Name of the frequency variable |
| n_operator | NoneType | None | Number of terms in the operator Fourier series. None defaults to n_vector - 1 |
| vg | Union | 6 | Specification of velocity groups |
| Returns | StationaryFloquetModel | Model for the Fourier coefficients of the periodic LGS system |
The StationaryFloquetModel solves for the periodic state of a modulated system after the transient dynamics have died out.
Build a stationary Floquet model for six Fourier harmonics of a system with sinusoidally modulated intensity:
Define values for the modulation frequency and light detuning:
Solve for the periodic state. The solution contains 13 Fourier coefficients for each density-matrix element in each velocity group:
The real and imaginary parts of the Fourier coefficients of the time-dependent return flux:
The total return flux reconstructed as a function of time:
The real and imaginary parts of the Fourier coefficients of the real and imaginary parts of the density-matrix elements:
The real and imaginary parts of the density-matrix elements reconstructed as a function of time: